פתיחת מקביליות בפייתון: ThreadPoolExecutor לעומת ProcessPoolExecutor

פייתון, למרות היותה שפת תכנות רב-תכליתית ונפוצה, יש לה מגבלות מסוימות בכל הנוגע למקביליות אמיתית בגלל נעילת המפרשן הגלובלית (GIL). מודול concurrent.futures מספק ממשק ברמה גבוהה לביצוע קריאות בצורה אסינכרונית, ומציע דרך לעקוף חלק מהמגבלות הללו ולשפר ביצועים עבור סוגים ספציפיים של משימות. מודול זה מספק שתי מחלקות עיקריות: ThreadPoolExecutor ו- ProcessPoolExecutor. מדריך מקיף זה יחקור את שתיהן, וידגיש את ההבדלים, החוזקות והחולשות שלהן, ויספק דוגמאות מעשיות כדי לעזור לך לבחור את ה-executor הנכון לצרכיך.

הבנת מקביליות ועיבוד מקבילי

לפני הצלילה למאפיינים הספציפיים של כל executor, חיוני להבין את המושגים של מקביליות ועיבוד מקבילי. מונחים אלה משמשים לעתים קרובות לסירוגין, אך יש להם משמעויות נפרדות:

• מקביליות: עוסק בניהול משימות מרובות בו-זמנית. זה קשור למבנה הקוד שלך כדי לטפל במספר דברים לכאורה בו-זמנית, גם אם הם למעשה משולבים על ליבת מעבד יחידה. תחשוב על זה כמו שף המנהל מספר סירים על כיריים בודדות - הם לא כולם רותחים באותו רגע *בדיוק*, אבל השף מנהל את כולם.
• עיבוד מקבילי: כרוך בביצוע בפועל של משימות מרובות באותו *זמן*, בדרך כלל על ידי שימוש בליבות מעבד מרובות. זה כמו שיש מספר שפים, שכל אחד מהם עובד על חלק אחר של הארוחה בו-זמנית.

ה-GIL של פייתון מונע במידה רבה מקביליות אמיתית עבור משימות תלויות מעבד בעת שימוש בשרשורים. הסיבה לכך היא שה-GIL מאפשר רק לשרשור אחד לשלוט על המפרשן של פייתון בכל רגע נתון. עם זאת, עבור משימות תלויות קלט/פלט, שבהן התוכנית מבלה את רוב זמנה בהמתנה לפעולות חיצוניות כמו בקשות רשת או קריאות דיסק, שרשורים עדיין יכולים לספק שיפורים משמעותיים בביצועים על ידי מתן אפשרות לשרשורים אחרים לפעול בזמן שאחד מחכה.

הצגת המודול concurrent.futures

המודול concurrent.futures מפשט את תהליך ביצוע המשימות בצורה אסינכרונית. הוא מספק ממשק ברמה גבוהה לעבודה עם שרשורים ותהליכים, תוך הפשטה של חלק ניכר מהמורכבות הכרוכה בניהולם ישירות. המושג המרכזי הוא "executor", שמנהל את ביצוע המשימות שנשלחו. שני ה-executors העיקריים הם:

• ThreadPoolExecutor: משתמש במאגר של שרשורים לביצוע משימות. מתאים למשימות תלויות קלט/פלט.
• ProcessPoolExecutor: משתמש במאגר של תהליכים לביצוע משימות. מתאים למשימות תלויות מעבד.

ThreadPoolExecutor: מינוף שרשורים למשימות תלויות קלט/פלט

ה- ThreadPoolExecutor יוצר מאגר של שרשורי עבודה לביצוע משימות. בגלל ה-GIL, שרשורים אינם אידיאליים עבור פעולות עתירות חישובים המפיקות תועלת ממקביליות אמיתית. עם זאת, הם מצטיינים בתרחישי תלות בקלט/פלט. בואו נחקור כיצד להשתמש בו:

שימוש בסיסי

הנה דוגמה פשוטה לשימוש ב-ThreadPoolExecutor להורדת דפי אינטרנט מרובים בו-זמנית:

import concurrent.futures
import requests
import time

urls = [
    "https://www.example.com",
    "https://www.google.com",
    "https://www.wikipedia.org",
    "https://www.python.org"
]


def download_page(url):
    try:
        response = requests.get(url, timeout=5)
        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
        print(f"Downloaded {url}: {len(response.content)} bytes")
        return len(response.content)
    except requests.exceptions.RequestException as e:
        print(f"Error downloading {url}: {e}")
        return 0


start_time = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    # Submit each URL to the executor
    futures = [executor.submit(download_page, url) for url in urls]

    # Wait for all tasks to complete
    total_bytes = sum(future.result() for future in concurrent.futures.as_completed(futures))

print(f"Total bytes downloaded: {total_bytes}")
print(f"Time taken: {time.time() - start_time:.2f} seconds")

הסבר:

1. אנו מייבאים את המודולים הדרושים: concurrent.futures, requests ו-time.
2. אנו מגדירים רשימה של כתובות URL להורדה.
3. הפונקציה download_page מאחזרת את התוכן של כתובת URL נתונה. טיפול בשגיאות כלול באמצעות `try...except` ו-`response.raise_for_status()` כדי לתפוס בעיות רשת פוטנציאליות.
4. אנו יוצרים ThreadPoolExecutor עם מקסימום של 4 שרשורי עובדים. הארגומנט max_workers שולט במספר המרבי של שרשורים שניתן להשתמש בהם בו-זמנית. הגדרה שלו גבוהה מדי עשויה שלא תמיד לשפר את הביצועים, במיוחד במשימות תלויות קלט/פלט שבהן רוחב הפס של הרשת הוא לרוב צוואר הבקבוק.
5. אנו משתמשים בהבנת רשימה כדי לשלוח כל כתובת URL ל-executor באמצעות executor.submit(download_page, url). פעולה זו מחזירה אובייקט Future עבור כל משימה.
6. הפונקציה concurrent.futures.as_completed(futures) מחזירה איטרטור שמניב עתידים כשהם מסתיימים. זה מונע המתנה לסיום כל המשימות לפני עיבוד התוצאות.
7. אנו עוברים על העתידים שהושלמו ומאחזרים את התוצאה של כל משימה באמצעות future.result(), ומסכמים את סך הבייטים שהורדו. טיפול בשגיאות בתוך `download_page` מבטיח שכישלונות בודדים לא יקריסו את התהליך כולו.
8. לבסוף, אנו מדפיסים את סך הבייטים שהורדו ואת הזמן שלקח.

היתרונות של ThreadPoolExecutor

• מקביליות פשוטה: מספק ממשק נקי וקל לשימוש לניהול שרשורים.
• ביצועים תלויי קלט/פלט: מצוין עבור משימות המבלות כמות משמעותית של זמן בהמתנה לפעולות קלט/פלט, כגון בקשות רשת, קריאות קבצים או שאילתות מסד נתונים.
• הפחתת תקורה: לשרשורים יש בדרך כלל תקורה נמוכה יותר בהשוואה לתהליכים, מה שהופך אותם ליעילים יותר עבור משימות הכרוכות במיתוג הקשר תכוף.

מגבלות של ThreadPoolExecutor

• הגבלת GIL: ה-GIL מגביל מקביליות אמיתית עבור משימות תלויות מעבד. רק שרשור אחד יכול לבצע קוד בייטים של פייתון בכל פעם, מה שמבטל את היתרונות של ליבות מרובות.
• מורכבות ניפוי שגיאות: ניפוי שגיאות של יישומי ריבוי שרשורים יכול להיות מאתגר בגלל תנאי מרוץ ובעיות אחרות הקשורות למקביליות.

ProcessPoolExecutor: שחרור ריבוי תהליכים למשימות תלויות מעבד

ה- ProcessPoolExecutor מתגבר על הגבלת ה-GIL על ידי יצירת מאגר של תהליכי עובדים. לכל תהליך יש מפרשן פייתון משלו ומרחב זיכרון משלו, מה שמאפשר מקביליות אמיתית במערכות מרובות ליבות. זה הופך אותו לאידיאלי עבור משימות תלויות מעבד הכרוכות בחישובים כבדים.

שימוש בסיסי

שקול משימה עתירת חישובים כמו חישוב סכום הריבועים עבור מגוון גדול של מספרים. כך משתמשים ב- ProcessPoolExecutor כדי לעבד משימה זו במקביל:

import concurrent.futures
import time
import os

def sum_of_squares(start, end):
    pid = os.getpid()
    print(f"Process ID: {pid}, Calculating sum of squares from {start} to {end}")
    total = 0
    for i in range(start, end + 1):
        total += i * i
    return total


if __name__ == "__main__": #Important for avoiding recursive spawning in some environments
    start_time = time.time()
    range_size = 1000000
    num_processes = 4
    ranges = [(i * range_size + 1, (i + 1) * range_size) for i in range(num_processes)]

    with concurrent.futures.ProcessPoolExecutor(max_workers=num_processes) as executor:
        futures = [executor.submit(sum_of_squares, start, end) for start, end in ranges]
        results = [future.result() for future in concurrent.futures.as_completed(futures)]

    total_sum = sum(results)
    print(f"Total sum of squares: {total_sum}")
    print(f"Time taken: {time.time() - start_time:.2f} seconds")

הסבר:

1. אנו מגדירים פונקציה sum_of_squares המחשבת את סכום הריבועים עבור טווח מספרים נתון. אנו כוללים את `os.getpid()` כדי לראות איזה תהליך מבצע כל טווח.
2. אנו מגדירים את גודל הטווח ואת מספר התהליכים לשימוש. הרשימה ranges נוצרת כדי לחלק את טווח החישוב הכולל לחלקים קטנים יותר, אחד עבור כל תהליך.
3. אנו יוצרים ProcessPoolExecutor עם המספר שצוין של תהליכי עובדים.
4. אנו שולחים כל טווח ל-executor באמצעות executor.submit(sum_of_squares, start, end).
5. אנו אוספים את התוצאות מכל עתיד באמצעות future.result().
6. אנו מסכמים את התוצאות מכל התהליכים כדי לקבל את הסכום הכולל הסופי.

הערה חשובה: בעת שימוש ב-ProcessPoolExecutor, במיוחד ב-Windows, עליך לכלול את הקוד שיוצר את ה-executor בתוך בלוק if __name__ == "__main__":. זה מונע קינון רקורסיבי של תהליכים, מה שעלול להוביל לשגיאות ולהתנהגות בלתי צפויה. הסיבה לכך היא שהמודול מיובא מחדש בכל תהליך צאצא.

היתרונות של ProcessPoolExecutor

• מקביליות אמיתית: מתגבר על הגבלת ה-GIL, ומאפשר מקביליות אמיתית במערכות מרובות ליבות עבור משימות תלויות מעבד.
• ביצועים משופרים עבור משימות תלויות מעבד: ניתן להשיג שיפורים משמעותיים בביצועים עבור פעולות עתירות חישובים.
• חוסן: אם תהליך אחד קורס, הוא לא בהכרח מפיל את התוכנית כולה, מכיוון שהתהליכים מבודדים זה מזה.

מגבלות של ProcessPoolExecutor

• תקורה גבוהה יותר: יצירה וניהול של תהליכים יש תקורה גבוהה יותר בהשוואה לשרשורים.
• תקשורת בין תהליכים: שיתוף נתונים בין תהליכים יכול להיות מורכב יותר ודורש מנגנוני תקשורת בין תהליכים (IPC), מה שיכול להוסיף תקורה.
• טביעת רגל זיכרון: לכל תהליך יש מרחב זיכרון משלו, מה שיכול להגדיל את טביעת הרגל הכוללת של הזיכרון של היישום. העברת כמויות גדולות של נתונים בין תהליכים יכולה להפוך לצוואר בקבוק.

בחירת ה-Executor הנכון: ThreadPoolExecutor לעומת ProcessPoolExecutor

המפתח לבחירה בין ThreadPoolExecutor ו- ProcessPoolExecutor טמון בהבנת אופי המשימות שלך:

• משימות תלויות קלט/פלט: אם המשימות שלך מבזבזות את רוב זמנן בהמתנה לפעולות קלט/פלט (לדוגמה, בקשות רשת, קריאות קבצים, שאילתות מסד נתונים), ThreadPoolExecutor הוא בדרך כלל הבחירה הטובה יותר. ה-GIL הוא פחות צוואר בקבוק בתרחישים אלה, והתקורה הנמוכה יותר של שרשורים הופכת אותם ליעילים יותר.
• משימות תלויות מעבד: אם המשימות שלך הן עתירות חישובים ומנצלות ליבות מרובות, ProcessPoolExecutor היא הדרך ללכת. הוא עוקף את הגבלת ה-GIL ומאפשר מקביליות אמיתית, וכתוצאה מכך שיפורים משמעותיים בביצועים.

הנה טבלה המסכמת את ההבדלים העיקריים:

תכונה	ThreadPoolExecutor	ProcessPoolExecutor
מודל מקביליות	ריבוי שרשורים	ריבוי תהליכים
השפעת GIL	מוגבל על ידי GIL	עוקף את GIL
מתאים ל	משימות תלויות קלט/פלט	משימות תלויות מעבד
תקורה	נמוכה יותר	גבוהה יותר
טביעת רגל זיכרון	נמוכה יותר	גבוהה יותר
תקשורת בין תהליכים	לא נדרשת (שרשורים חולקים זיכרון)	נדרש לשיתוף נתונים
חוסן	פחות חזק (קריסה יכולה להשפיע על התהליך כולו)	יותר חזק (תהליכים מבודדים)

טכניקות ושיקולים מתקדמים

שליחת משימות עם ארגומנטים

שני ה-executors מאפשרים לך להעביר ארגומנטים לפונקציה המבוצעת. זה נעשה באמצעות שיטת submit():

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function, arg1, arg2)
    result = future.result()

טיפול בחריגות

חריגות שמופעלות בתוך הפונקציה המבוצעת אינן מועברות אוטומטית לשרשור או לתהליך הראשי. אתה צריך לטפל בהם במפורש בעת אחזור התוצאה של Future:

with concurrent.futures.ThreadPoolExecutor() as executor:
    future = executor.submit(my_function)
    try:
        result = future.result()
    except Exception as e:
        print(f"An exception occurred: {e}")

שימוש ב-`map` עבור משימות פשוטות

עבור משימות פשוטות שבהן ברצונך להחיל את אותה פונקציה על רצף של קלטים, השיטה map() מספקת דרך תמציתית לשלוח משימות:

def square(x):
    return x * x


with concurrent.futures.ProcessPoolExecutor() as executor:
    numbers = [1, 2, 3, 4, 5]
    results = executor.map(square, numbers)
    print(list(results))

שליטה במספר העובדים

הארגומנט max_workers בשני ThreadPoolExecutor ו-ProcessPoolExecutor שולט במספר המרבי של שרשורים או תהליכים שניתן להשתמש בהם בו-זמנית. בחירת הערך הנכון עבור max_workers חשובה לביצועים. נקודת התחלה טובה היא מספר ליבות המעבד הזמינות במערכת שלך. עם זאת, עבור משימות תלויות קלט/פלט, ייתכן שתרוויח משימוש ביותר שרשורים מאשר ליבות, מכיוון ששרשורים יכולים לעבור למשימות אחרות בזמן שהם ממתינים לקלט/פלט. ניסוי ופרופיל הם לעתים קרובות הכרחיים כדי לקבוע את הערך האופטימלי.

מעקב אחר התקדמות

המודול concurrent.futures אינו מספק מנגנונים מובנים למעקב ישיר אחר התקדמות המשימות. עם זאת, באפשרותך ליישם מעקב אחר ההתקדמות שלך על ידי שימוש בקריאות חזרה או משתנים משותפים. ניתן לשלב ספריות כמו `tqdm` להצגת סרגל התקדמות.

דוגמאות מהעולם האמיתי

בואו נבחן כמה תרחישים מהעולם האמיתי שבהם ניתן להשתמש ב-ThreadPoolExecutor וב-ProcessPoolExecutor ביעילות:

• גרוד דפי אינטרנט: הורדה וניתוח של דפי אינטרנט מרובים בו-זמנית באמצעות ThreadPoolExecutor. כל שרשור יכול לטפל בדף אינטרנט אחר, מה שמשפר את מהירות הגרוד הכוללת. שימו לב לתנאי השירות של האתר והימנעו מעומס יתר על השרתים שלהם.
• עיבוד תמונה: החלת מסנני תמונה או טרנספורמציות על קבוצה גדולה של תמונות באמצעות ProcessPoolExecutor. כל תהליך יכול לטפל בתמונה אחרת, תוך ניצול ליבות מרובות לעיבוד מהיר יותר. שקול ספריות כמו OpenCV לעיבוד תמונה יעיל.
• ניתוח נתונים: ביצוע חישובים מורכבים על מערכי נתונים גדולים באמצעות ProcessPoolExecutor. כל תהליך יכול לנתח תת-קבוצה של הנתונים, ולהפחית את זמן הניתוח הכולל. Pandas ו-NumPy הן ספריות פופולריות לניתוח נתונים בפייתון.
• למידת מכונה: אימון מודלים של למידת מכונה באמצעות ProcessPoolExecutor. אלגוריתמים מסוימים של למידת מכונה ניתנים לעיבוד במקביל ביעילות, מה שמאפשר זמני אימון מהירים יותר. ספריות כמו scikit-learn ו- TensorFlow מציעות תמיכה בעיבוד מקבילי.
• קידוד וידאו: המרת קובצי וידאו לפורמטים שונים באמצעות ProcessPoolExecutor. כל תהליך יכול לקודד קטע וידאו אחר, מה שהופך את תהליך הקידוד הכולל למהיר יותר.

שיקולים גלובליים

בעת פיתוח יישומים מקביליים עבור קהל גלובלי, חשוב לקחת בחשבון את הדברים הבאים:

• אזורי זמן: שימו לב לאזורי זמן בעת ​​התמודדות עם פעולות רגישות לזמן. השתמש בספריות כמו pytz כדי לטפל בהמרות אזור זמן.
• אזורים: ודא שהאפליקציה שלך מטפלת באזורים שונים כראוי. השתמש בספריות כמו locale כדי לעצב מספרים, תאריכים ומטבעות בהתאם לאזור המשתמש.
• קידוד תווים: השתמש ב-Unicode (UTF-8) כקידוד התווים המוגדר כברירת מחדל כדי לתמוך במגוון רחב של שפות.
• בינאום (i18n) ולוקליזציה (l10n): עצב את היישום שלך כך שיהיה קל לבצע בו בינאום ולוקליזציה. השתמש ב-gettext או בספריות תרגום אחרות כדי לספק תרגומים עבור שפות שונות.
• חביון רשת: שקול את חביון הרשת בעת תקשורת עם שירותים מרוחקים. הטמע פסיקת זמן וטיפול בשגיאות מתאימים כדי להבטיח שהיישום שלך יהיה עמיד לבעיות רשת. מיקום גיאוגרפי של שרתים יכול להשפיע באופן ניכר על חביון. שקול להשתמש ברשתות אספקת תוכן (CDNs) כדי לשפר את הביצועים עבור משתמשים באזורים שונים.

סיכום

המודול concurrent.futures מספק דרך רבת עוצמה ונוחה להציג מקביליות ועיבוד מקבילי ביישומי הפייתון שלך. על ידי הבנת ההבדלים בין ThreadPoolExecutor ו- ProcessPoolExecutor, ועל ידי התחשבות מדוקדקת באופי המשימות שלך, אתה יכול לשפר משמעותית את הביצועים ואת המהירות של הקוד שלך. זכור לבצע פרופיל של הקוד שלך ולנסות תצורות שונות כדי למצוא את ההגדרות האופטימליות עבור מקרה השימוש הספציפי שלך. כמו כן, היה מודע למגבלות ה-GIL ולמורכבויות הפוטנציאליות של תכנות ריבוי שרשורים וריבוי תהליכים. עם תכנון ויישום קפדניים, אתה יכול לפתוח את הפוטנציאל המלא של מקביליות בפייתון וליצור יישומים חזקים וניתנים להרחבה עבור קהל גלובלי.